
声明 模块 "stream" {

    //@@{ 事件组:events }
    导入 * 转为 事件组 来自 "events";

    //@@{ 内部:internal, 事件组:events, 事件发生器_:EventEmitter }
    类别 内部 扩展 事件组.事件发生器_ {

        //@@{ 管道:pipe, 可写流_:WritableStream, 结束:end }
        管道<T 扩展 NodeJS.可写流_>(目的地: T, 选项组?: { 结束?: 真假; }): T;
    }

    //@@{ 内部:internal }
    名域 内部 {

        //@@{ 流_:Stream, 内部:internal }
        类别 流_ 扩展 内部 { }

        //@@{ 可读的选项_:ReadableOptions }
        接口 可读的选项_ {

            //@@{ 高水位标记:highWaterMark }
            高水位标记?: 数字;

            //@@{ 编码:encoding }
            编码?: 文字;

            //@@{ 对象模式:objectMode }
            对象模式?: 真假;

            //@@{ 读:read, 可读的_:Readable }
            读?(本体: 可读的_, 大小: 数字): 无值;

            //@@{ 销毁:destroy, 可读的_:Readable, 错误_:Error }
            销毁?(本体: 可读的_, 错误: 错误_ | 空值, 回调: (错误: 错误_ | 空值) => 无值): 无值;

            //@@{ 自动销毁:autoDestroy }
            自动销毁?: 真假;
        }

        //@@{ 可读的_:Readable, 流_:Stream, 可读流_:ReadableStream }
        类别 可读的_ 扩展 流_ 实现 NodeJS.可读流_ {

            //@@{ 可读的:readable }
            可读的: 真假;

            //@@{ 可读高水位线:readableHighWaterMark }
            只读 可读高水位线: 数字;

            //@@{ 可读长度:readableLength }
            只读 可读长度: 数字;

            //@@{ 可读的选项_:ReadableOptions }
            构造(选项?: 可读的选项_);

            //@@{ _读:_read }
            _读(大小: 数字): 无值;

            //@@{ 读:read }
            读(大小?: 数字): 任意;

            //@@{ 设置编码:setEncoding }
            设置编码(编码: 文字): 本体;

            //@@{ 暂停:pause }
            暂停(): 本体;

            //@@{ 恢复:resume }
            恢复(): 本体;

            //@@{ 是暂停的:isPaused }
            是暂停的(): 真假;

            //@@{ 取消管道:unpipe, 可写流_:WritableStream }
            取消管道(目的地?: NodeJS.可写流_): 本体;

            //@@{ 推入:unshift }
            推入(块: 任意): 无值;

            //@@{ 包装:wrap, 可读流_:ReadableStream }
            包装(旧流: NodeJS.可读流_): 本体;

            //@@{ 压入:push }
            压入(块: 任意, 编码?: 文字): 真假;

            //@@{ _销毁:_destroy, 错误_:Error }
            _销毁(错误: 错误_ | 空值, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 销毁:destroy, 错误_:Error }
            销毁(错误?: 错误_): 无值;

            /**
             * Event emitter
             * The defined events on documents including:
             * 1. close
             * 2. data
             * 3. end
             * 4. readable
             * 5. error
             */

            //@@{ 添加监听器:addListener, "关闭":"close" }
            添加监听器(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 添加监听器:addListener, "数据":"data" }
            添加监听器(事件: "数据", 监听器: (块: 任意) => 无值): 本体;

            //@@{ 添加监听器:addListener, "结束":"end" }
            添加监听器(事件: "结束", 监听器: () => 无值): 本体;

            //@@{ 添加监听器:addListener, "可读的":"readable" }
            添加监听器(事件: "可读的", 监听器: () => 无值): 本体;

            //@@{ 添加监听器:addListener, "错误":"error", 错误_:Error }
            添加监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 添加监听器:addListener }
            添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

            //@@{ 发出:emit, "关闭":"close" }
            发出(事件: "关闭"): 真假;

            //@@{ 发出:emit, "数据":"data" }
            发出(事件: "数据", 块: 任意): 真假;

            //@@{ 发出:emit, "结束":"end" }
            发出(事件: "结束"): 真假;

            //@@{ 发出:emit, "可读的":"readable" }
            发出(事件: "可读的"): 真假;

            //@@{ 发出:emit, "错误":"error", 错误_:Error }
            发出(事件: "错误", 错: 错误_): 真假;

            //@@{ 发出:emit }
            发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

            //@@{ 正在:on, "关闭":"close" }
            正在(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 正在:on, "数据":"data" }
            正在(事件: "数据", 监听器: (块: 任意) => 无值): 本体;

            //@@{ 正在:on, "结束":"end" }
            正在(事件: "结束", 监听器: () => 无值): 本体;

            //@@{ 正在:on, "可读的":"readable" }
            正在(事件: "可读的", 监听器: () => 无值): 本体;

            //@@{ 正在:on, "错误":"error", 错误_:Error }
            正在(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 正在:on }
            正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

            //@@{ 一次:once, "关闭":"close" }
            一次(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 一次:once, "数据":"data" }
            一次(事件: "数据", 监听器: (块: 任意) => 无值): 本体;

            //@@{ 一次:once, "结束":"end" }
            一次(事件: "结束", 监听器: () => 无值): 本体;

            //@@{ 一次:once, "可读的":"readable" }
            一次(事件: "可读的", 监听器: () => 无值): 本体;

            //@@{ 一次:once, "错误":"error", 错误_:Error }
            一次(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 一次:once }
            一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

            //@@{ 预处理监听器:prependListener, "关闭":"close" }
            预处理监听器(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 预处理监听器:prependListener, "数据":"data" }
            预处理监听器(事件: "数据", 监听器: (块: 任意) => 无值): 本体;

            //@@{ 预处理监听器:prependListener, "结束":"end" }
            预处理监听器(事件: "结束", 监听器: () => 无值): 本体;

            //@@{ 预处理监听器:prependListener, "可读的":"readable" }
            预处理监听器(事件: "可读的", 监听器: () => 无值): 本体;

            //@@{ 预处理监听器:prependListener, "错误":"error", 错误_:Error }
            预处理监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 预处理监听器:prependListener }
            预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener, "关闭":"close" }
            预处理一次监听器(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener, "数据":"data" }
            预处理一次监听器(事件: "数据", 监听器: (块: 任意) => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener, "结束":"end" }
            预处理一次监听器(事件: "结束", 监听器: () => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener, "可读的":"readable" }
            预处理一次监听器(事件: "可读的", 监听器: () => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener, "错误":"error", 错误_:Error }
            预处理一次监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener }
            预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

            //@@{ 移除监听器:removeListener, "关闭":"close" }
            移除监听器(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 移除监听器:removeListener, "数据":"data" }
            移除监听器(事件: "数据", 监听器: (块: 任意) => 无值): 本体;

            //@@{ 移除监听器:removeListener, "结束":"end" }
            移除监听器(事件: "结束", 监听器: () => 无值): 本体;

            //@@{ 移除监听器:removeListener, "可读的":"readable" }
            移除监听器(事件: "可读的", 监听器: () => 无值): 本体;

            //@@{ 移除监听器:removeListener, "错误":"error", 错误_:Error }
            移除监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 移除监听器:removeListener }
            移除监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

            //@@{ 符号_:Symbol, 异步迭代器:asyncIterator, 异步可迭代迭代器_:AsyncIterableIterator }
            [符号_.异步迭代器](): 异步可迭代迭代器_<任意>;
        }

        //@@{ 可写的选项_:WritableOptions }
        接口 可写的选项_ {

            //@@{ 高水位标记:highWaterMark }
            高水位标记?: 数字;

            //@@{ 解码字符串:decodeStrings }
            解码字符串?: 真假;

            //@@{ 默认编码:defaultEncoding }
            默认编码?: 文字;

            //@@{ 对象模式:objectMode }
            对象模式?: 真假;

            //@@{ 发射近距离:emitClose }
            发射近距离?: 真假;

            //@@{ 写:write, 可写的_:Writable, 错误_:Error }
            写?(本体: 可写的_, 块: 任意, 编码: 文字, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 写批量:writev, 可写的_:Writable, 数组_:Array, 块:chunk, 编码:encoding, 错误_:Error }
            写批量?(本体: 可写的_, 块: 数组_<{ 块: 任意, 编码: 文字 }>, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 销毁:destroy, 可写的_:Writable, 错误_:Error }
            销毁?(本体: 可写的_, 错误: 错误_ | 空值, 回调: (错误: 错误_ | 空值) => 无值): 无值;

            //@@{ 最后:final, 可写的_:Writable, 错误_:Error }
            最后?(本体: 可写的_, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 自动销毁:autoDestroy }
            自动销毁?: 真假;
        }

        //@@{ 可写的_:Writable, 流_:Stream, 可写流_:WritableStream }
        类别 可写的_ 扩展 流_ 实现 NodeJS.可写流_ {

            //@@{ 可写的:writable }
            可写的: 真假;

            //@@{ 可写高水位线:writableHighWaterMark }
            只读 可写高水位线: 数字;

            //@@{ 可写长度:writableLength }
            只读 可写长度: 数字;

            //@@{ 可写的选项_:WritableOptions }
            构造(选项?: 可写的选项_);

            //@@{ _写:_write, 错误_:Error }
            _写(块: 任意, 编码: 文字, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ _书写:_writev, 数组_:Array, 块:chunk, 编码:encoding, 错误_:Error }
            _书写?(块: 数组_<{ 块: 任意, 编码: 文字 }>, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ _销毁:_destroy, 错误_:Error }
            _销毁(错误: 错误_ | 空值, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ _最后:_final, 错误_:Error }
            _最后(回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 写:write, 错误_:Error }
            写(块: 任意, 回调?: (错误: 错误_ | 空值 | 未定) => 无值): 真假;

            //@@{ 写:write, 错误_:Error }
            写(块: 任意, 编码: 文字, 回调?: (错误: 错误_ | 空值 | 未定) => 无值): 真假;

            //@@{ 设置默认编码:setDefaultEncoding }
            设置默认编码(编码: 文字): 本体;

            //@@{ 结束:end }
            结束(回调?: () => 无值): 无值;

            //@@{ 结束:end }
            结束(块: 任意, 回调?: () => 无值): 无值;

            //@@{ 结束:end }
            结束(块: 任意, 编码: 文字, 回调?: () => 无值): 无值;

            //@@{ 写入内存缓冲区:cork }
            写入内存缓冲区(): 无值;

            //@@{ 输出内存缓冲区:uncork }
            输出内存缓冲区(): 无值;

            //@@{ 销毁:destroy, 错误_:Error }
            销毁(错误?: 错误_): 无值;

            /**
             * Event emitter
             * The defined events on documents including:
             * 1. close
             * 2. drain
             * 3. error
             * 4. finish
             * 5. pipe
             * 6. unpipe
             */

            //@@{ 添加监听器:addListener, "关闭":"close" }
            添加监听器(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 添加监听器:addListener, "排空":"drain" }
            添加监听器(事件: "排空", 监听器: () => 无值): 本体;

            //@@{ 添加监听器:addListener, "错误":"error", 错误_:Error }
            添加监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 添加监听器:addListener, "完成":"finish" }
            添加监听器(事件: "完成", 监听器: () => 无值): 本体;

            //@@{ 添加监听器:addListener, "管道":"pipe", 可读的_:Readable }
            添加监听器(事件: "管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 添加监听器:addListener, "取消管道":"unpipe", 可读的_:Readable }
            添加监听器(事件: "取消管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 添加监听器:addListener }
            添加监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

            //@@{ 发出:emit, "关闭":"close" }
            发出(事件: "关闭"): 真假;

            //@@{ 发出:emit, "排空":"drain" }
            发出(事件: "排空"): 真假;

            //@@{ 发出:emit, "错误":"error", 错误_:Error }
            发出(事件: "错误", 错: 错误_): 真假;

            //@@{ 发出:emit, "完成":"finish" }
            发出(事件: "完成"): 真假;

            //@@{ 发出:emit, "管道":"pipe", 可读的_:Readable }
            发出(事件: "管道", 源: 可读的_): 真假;

            //@@{ 发出:emit, "取消管道":"unpipe", 可读的_:Readable }
            发出(事件: "取消管道", 源: 可读的_): 真假;

            //@@{ 发出:emit }
            发出(事件: 文字 | 符号, ...参数组: 任意[]): 真假;

            //@@{ 正在:on, "关闭":"close" }
            正在(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 正在:on, "排空":"drain" }
            正在(事件: "排空", 监听器: () => 无值): 本体;

            //@@{ 正在:on, "错误":"error", 错误_:Error }
            正在(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 正在:on, "完成":"finish" }
            正在(事件: "完成", 监听器: () => 无值): 本体;

            //@@{ 正在:on, "管道":"pipe", 可读的_:Readable }
            正在(事件: "管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 正在:on, "取消管道":"unpipe", 可读的_:Readable }
            正在(事件: "取消管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 正在:on }
            正在(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

            //@@{ 一次:once, "关闭":"close" }
            一次(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 一次:once, "排空":"drain" }
            一次(事件: "排空", 监听器: () => 无值): 本体;

            //@@{ 一次:once, "错误":"error", 错误_:Error }
            一次(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 一次:once, "完成":"finish" }
            一次(事件: "完成", 监听器: () => 无值): 本体;

            //@@{ 一次:once, "管道":"pipe", 可读的_:Readable }
            一次(事件: "管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 一次:once, "取消管道":"unpipe", 可读的_:Readable }
            一次(事件: "取消管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 一次:once }
            一次(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

            //@@{ 预处理监听器:prependListener, "关闭":"close" }
            预处理监听器(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 预处理监听器:prependListener, "排空":"drain" }
            预处理监听器(事件: "排空", 监听器: () => 无值): 本体;

            //@@{ 预处理监听器:prependListener, "错误":"error", 错误_:Error }
            预处理监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 预处理监听器:prependListener, "完成":"finish" }
            预处理监听器(事件: "完成", 监听器: () => 无值): 本体;

            //@@{ 预处理监听器:prependListener, "管道":"pipe", 可读的_:Readable }
            预处理监听器(事件: "管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 预处理监听器:prependListener, "取消管道":"unpipe", 可读的_:Readable }
            预处理监听器(事件: "取消管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 预处理监听器:prependListener }
            预处理监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener, "关闭":"close" }
            预处理一次监听器(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener, "排空":"drain" }
            预处理一次监听器(事件: "排空", 监听器: () => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener, "错误":"error", 错误_:Error }
            预处理一次监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener, "完成":"finish" }
            预处理一次监听器(事件: "完成", 监听器: () => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener, "管道":"pipe", 可读的_:Readable }
            预处理一次监听器(事件: "管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener, "取消管道":"unpipe", 可读的_:Readable }
            预处理一次监听器(事件: "取消管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 预处理一次监听器:prependOnceListener }
            预处理一次监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;

            //@@{ 移除监听器:removeListener, "关闭":"close" }
            移除监听器(事件: "关闭", 监听器: () => 无值): 本体;

            //@@{ 移除监听器:removeListener, "排空":"drain" }
            移除监听器(事件: "排空", 监听器: () => 无值): 本体;

            //@@{ 移除监听器:removeListener, "错误":"error", 错误_:Error }
            移除监听器(事件: "错误", 监听器: (错: 错误_) => 无值): 本体;

            //@@{ 移除监听器:removeListener, "完成":"finish" }
            移除监听器(事件: "完成", 监听器: () => 无值): 本体;

            //@@{ 移除监听器:removeListener, "管道":"pipe", 可读的_:Readable }
            移除监听器(事件: "管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 移除监听器:removeListener, "取消管道":"unpipe", 可读的_:Readable }
            移除监听器(事件: "取消管道", 监听器: (源: 可读的_) => 无值): 本体;

            //@@{ 移除监听器:removeListener }
            移除监听器(事件: 文字 | 符号, 监听器: (...参数组: 任意[]) => 无值): 本体;
        }

        //@@{ 双工选项_:DuplexOptions, 可读的选项_:ReadableOptions, 可写的选项_:WritableOptions }
        接口 双工选项_ 扩展 可读的选项_, 可写的选项_ {

            //@@{ 允许半开:allowHalfOpen }
            允许半开?: 真假;

            //@@{ 可读的对象模式:readableObjectMode }
            可读的对象模式?: 真假;

            //@@{ 可写的对象模式:writableObjectMode }
            可写的对象模式?: 真假;

            //@@{ 读:read, 双工_:Duplex }
            读?(本体: 双工_, 大小: 数字): 无值;

            //@@{ 写:write, 双工_:Duplex, 错误_:Error }
            写?(本体: 双工_, 块: 任意, 编码: 文字, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 写批量:writev, 双工_:Duplex, 数组_:Array, 块:chunk, 编码:encoding, 错误_:Error }
            写批量?(本体: 双工_, 块: 数组_<{ 块: 任意, 编码: 文字 }>, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 最后:final, 双工_:Duplex, 错误_:Error }
            最后?(本体: 双工_, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 销毁:destroy, 双工_:Duplex, 错误_:Error }
            销毁?(本体: 双工_, 错误: 错误_ | 空值, 回调: (错误: 错误_ | 空值) => 无值): 无值;
        }

        // Note: Duplex extends both Readable and Writable.

        //@@{ 双工_:Duplex, 可读的_:Readable, 可写的_:Writable }
        类别 双工_ 扩展 可读的_ 实现 可写的_ {

            //@@{ 可写的:writable }
            可写的: 真假;

            //@@{ 可写高水位线:writableHighWaterMark }
            只读 可写高水位线: 数字;

            //@@{ 可写长度:writableLength }
            只读 可写长度: 数字;

            //@@{ 双工选项_:DuplexOptions }
            构造(选项?: 双工选项_);

            //@@{ _写:_write, 错误_:Error }
            _写(块: 任意, 编码: 文字, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ _书写:_writev, 数组_:Array, 块:chunk, 编码:encoding, 错误_:Error }
            _书写?(块: 数组_<{ 块: 任意, 编码: 文字 }>, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ _销毁:_destroy, 错误_:Error }
            _销毁(错误: 错误_ | 空值, 回调: (错误: 错误_ | 空值) => 无值): 无值;

            //@@{ _最后:_final, 错误_:Error }
            _最后(回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 写:write, 错误_:Error }
            写(块: 任意, 编码?: 文字, 回调?: (错误: 错误_ | 空值 | 未定) => 无值): 真假;

            //@@{ 写:write, 错误_:Error }
            写(块: 任意, 回调?: (错误: 错误_ | 空值 | 未定) => 无值): 真假;

            //@@{ 设置默认编码:setDefaultEncoding }
            设置默认编码(编码: 文字): 本体;

            //@@{ 结束:end }
            结束(回调?: () => 无值): 无值;

            //@@{ 结束:end }
            结束(块: 任意, 回调?: () => 无值): 无值;

            //@@{ 结束:end }
            结束(块: 任意, 编码?: 文字, 回调?: () => 无值): 无值;

            //@@{ 写入内存缓冲区:cork }
            写入内存缓冲区(): 无值;

            //@@{ 输出内存缓冲区:uncork }
            输出内存缓冲区(): 无值;
        }

        //@@{ 转换回调_:TransformCallback, 错误_:Error }
        类型 转换回调_ = (错误?: 错误_ | 空值, 数据?: 任意) => 无值;

        //@@{ 变换选项_:TransformOptions, 双工选项_:DuplexOptions }
        接口 变换选项_ 扩展 双工选项_ {

            //@@{ 读:read, 变换_:Transform }
            读?(本体: 变换_, 大小: 数字): 无值;

            //@@{ 写:write, 变换_:Transform, 错误_:Error }
            写?(本体: 变换_, 块: 任意, 编码: 文字, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 写批量:writev, 变换_:Transform, 数组_:Array, 块:chunk, 编码:encoding, 错误_:Error }
            写批量?(本体: 变换_, 块: 数组_<{ 块: 任意, 编码: 文字 }>, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 最后:final, 变换_:Transform, 错误_:Error }
            最后?(本体: 变换_, 回调: (错误?: 错误_ | 空值) => 无值): 无值;

            //@@{ 销毁:destroy, 变换_:Transform, 错误_:Error }
            销毁?(本体: 变换_, 错误: 错误_ | 空值, 回调: (错误: 错误_ | 空值) => 无值): 无值;

            //@@{ 变换:transform, 变换_:Transform, 转换回调_:TransformCallback }
            变换?(本体: 变换_, 块: 任意, 编码: 文字, 回调: 转换回调_): 无值;

            //@@{ 刷新:flush, 变换_:Transform, 转换回调_:TransformCallback }
            刷新?(本体: 变换_, 回调: 转换回调_): 无值;
        }

        //@@{ 变换_:Transform, 双工_:Duplex }
        类别 变换_ 扩展 双工_ {

            //@@{ 变换选项_:TransformOptions }
            构造(选项?: 变换选项_);

            //@@{ _变换:_transform, 转换回调_:TransformCallback }
            _变换(块: 任意, 编码: 文字, 回调: 转换回调_): 无值;

            //@@{ _刷新:_flush, 转换回调_:TransformCallback }
            _刷新(回调: 转换回调_): 无值;
        }

        //@@{ 直接通过_:PassThrough, 变换_:Transform }
        类别 直接通过_ 扩展 变换_ { }

        //@@{ 完成了:finished, 可读流_:ReadableStream, 可写流_:WritableStream, 读写流_:ReadWriteStream }
        //@@{ 错误异常_:ErrnoException }
        函数 完成了(流: NodeJS.可读流_ | NodeJS.可写流_ | NodeJS.读写流_, 回调: (错?: NodeJS.错误异常_ | 空值) => 无值): () => 无值;

        //@@{ 完成了:finished }
        名域 完成了 {

            //@@{ __转为预设__:__promisify__, 可读流_:ReadableStream, 可写流_:WritableStream }
            //@@{ 读写流_:ReadWriteStream, 预设_:Promise }
            函数 __转为预设__(流: NodeJS.可读流_ | NodeJS.可写流_ | NodeJS.读写流_): 预设_<无值>;
        }

        //@@{ 管道:pipeline, 可写流_:WritableStream, 可读流_:ReadableStream, 错误异常_:ErrnoException }
        函数 管道<T 扩展 NodeJS.可写流_>(流1: NodeJS.可读流_, 流2: T, 回调?: (错: NodeJS.错误异常_ | 空值) => 无值): T;

        //@@{ 管道:pipeline, 可写流_:WritableStream, 可读流_:ReadableStream, 读写流_:ReadWriteStream }
        //@@{ 错误异常_:ErrnoException }
        函数 管道<T 扩展 NodeJS.可写流_>(流1: NodeJS.可读流_, 流2: NodeJS.读写流_, 流3: T, 回调?: (错: NodeJS.错误异常_ | 空值) => 无值): T;

        //@@{ 管道:pipeline, 可写流_:WritableStream }
        函数 管道<T 扩展 NodeJS.可写流_>(

            //@@{ 可读流_:ReadableStream }
            流1: NodeJS.可读流_,

            //@@{ 读写流_:ReadWriteStream }
            流2: NodeJS.读写流_,

            //@@{ 读写流_:ReadWriteStream }
            流3: NodeJS.读写流_,
            流4: T,

            //@@{ 错误异常_:ErrnoException }
            回调?: (错: NodeJS.错误异常_ | 空值) => 无值,
        ): T;

        //@@{ 管道:pipeline, 可写流_:WritableStream }
        函数 管道<T 扩展 NodeJS.可写流_>(

            //@@{ 可读流_:ReadableStream }
            流1: NodeJS.可读流_,

            //@@{ 读写流_:ReadWriteStream }
            流2: NodeJS.读写流_,

            //@@{ 读写流_:ReadWriteStream }
            流3: NodeJS.读写流_,

            //@@{ 读写流_:ReadWriteStream }
            流4: NodeJS.读写流_,
            流5: T,

            //@@{ 错误异常_:ErrnoException }
            回调?: (错: NodeJS.错误异常_ | 空值) => 无值,
        ): T;

        //@@{ 管道:pipeline, 数组_:Array, 可读流_:ReadableStream, 可写流_:WritableStream, 读写流_:ReadWriteStream }
        //@@{ 错误异常_:ErrnoException }
        函数 管道(流组: 数组_<NodeJS.可读流_ | NodeJS.可写流_ | NodeJS.读写流_>, 回调?: (错: NodeJS.错误异常_ | 空值) => 无值): NodeJS.可写流_;

        //@@{ 管道:pipeline }
        函数 管道(

            //@@{ 可读流_:ReadableStream }
            流1: NodeJS.可读流_,

            //@@{ 读写流_:ReadWriteStream, 可写流_:WritableStream }
            流2: NodeJS.读写流_ | NodeJS.可写流_,

            //@@{ 数组_:Array, 读写流_:ReadWriteStream, 可写流_:WritableStream, 错误异常_:ErrnoException }
            ...流组: 数组_<NodeJS.读写流_ | NodeJS.可写流_ | ((错: NodeJS.错误异常_ | 空值) => 无值)>,

        //@@{ 可写流_:WritableStream }
        ): NodeJS.可写流_;

        //@@{ 管道:pipeline }
        名域 管道 {

            //@@{ __转为预设__:__promisify__, 可读流_:ReadableStream, 可写流_:WritableStream }
            //@@{ 预设_:Promise }
            函数 __转为预设__(流1: NodeJS.可读流_, 流2: NodeJS.可写流_): 预设_<无值>;

            //@@{ __转为预设__:__promisify__, 可读流_:ReadableStream, 读写流_:ReadWriteStream }
            //@@{ 可写流_:WritableStream, 预设_:Promise }
            函数 __转为预设__(流1: NodeJS.可读流_, 流2: NodeJS.读写流_, 流3: NodeJS.可写流_): 预设_<无值>;

            //@@{ __转为预设__:__promisify__, 可读流_:ReadableStream, 读写流_:ReadWriteStream }
            //@@{ 可写流_:WritableStream, 预设_:Promise }
            函数 __转为预设__(流1: NodeJS.可读流_, 流2: NodeJS.读写流_, 流3: NodeJS.读写流_, 流4: NodeJS.可写流_): 预设_<无值>;

            //@@{ __转为预设__:__promisify__ }
            函数 __转为预设__(

                //@@{ 可读流_:ReadableStream }
                流1: NodeJS.可读流_,

                //@@{ 读写流_:ReadWriteStream }
                流2: NodeJS.读写流_,

                //@@{ 读写流_:ReadWriteStream }
                流3: NodeJS.读写流_,

                //@@{ 读写流_:ReadWriteStream }
                流4: NodeJS.读写流_,

                //@@{ 可写流_:WritableStream }
                流5: NodeJS.可写流_,

            //@@{ 预设_:Promise }
            ): 预设_<无值>;

            //@@{ __转为预设__:__promisify__, 数组_:Array, 可读流_:ReadableStream, 可写流_:WritableStream }
            //@@{ 读写流_:ReadWriteStream, 预设_:Promise }
            函数 __转为预设__(流组: 数组_<NodeJS.可读流_ | NodeJS.可写流_ | NodeJS.读写流_>): 预设_<无值>;

            //@@{ __转为预设__:__promisify__ }
            函数 __转为预设__(

                //@@{ 可读流_:ReadableStream }
                流1: NodeJS.可读流_,

                //@@{ 读写流_:ReadWriteStream, 可写流_:WritableStream }
                流2: NodeJS.读写流_ | NodeJS.可写流_,

                //@@{ 数组_:Array, 读写流_:ReadWriteStream, 可写流_:WritableStream }
                ...流组: 数组_<NodeJS.读写流_ | NodeJS.可写流_>,

            //@@{ 预设_:Promise }
            ): 预设_<无值>;
        }

        //@@{ 管道_:Pipe }
        接口 管道_ { }
    }

    //@@{ 内部:internal }
    导出 = 内部;
}
